/**
 * 冒泡排序: 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
 * 空间复杂度: 空间复杂度就是表示算法的存储空间和数据规模之间的关系。每次数组赋值都会申请一个空间存储变量.
 * 时间复杂度: 代码的总执行时间 T(n) 与每行代码的执行次数成正比.
 * 空间复杂度:O(1)
 * 时间复杂度: 最坏：O(n*n) 最好：O(n)
 */

function selectionSort(arr) {
  let len = arr.length
  for (let i = 0; i < len - 1; i++) {
    let done = true
    for (let j = 1; j < len - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        let temp = arr[j]
        arr[j] = arr[j + 1]
        arr[j + 1] = temp
        done = false
      }
    }
    if (done) break
  }
  return arr
}

/**
 * 快速排序: https://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html
 * 在数据集之中，选择一个元素作为"基准"
 * 所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边
 * 对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止
 * 时间复杂度最好为o(n) 最坏为(n^2) 平均为o(n^2)   空间复杂度为o(1)
 */

var quickSort = function (arr) {
  if (arr.length <= 1) {
    return arr
  }
  var pivotIndex = Math.floor(arr.length / 2)
  var pivot = arr.splice(pivotIndex, 1)[0]
  var left = []
  var right = []
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i])
    } else {
      right.push(arr[i])
    }
  }
  return quickSort(left).concat([pivot], quickSort(right))
}

/**
 * 选择排序: 每次都找一个最大或者最小的排在开始.
 * 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置;
 * 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
 * 重复第二步，直到所有元素均排序完毕
 */

function selectionSort1(arr) {
  let len = arr.length
  for (let i = 0; i < len - 1; i++) {
    let index = i
    for (let j = i + 1; j < len; j++) {
      if (arr[j] < arr[index]) index = j
    }
    let temp = arr[i]
    arr[i] = arr[index]
    arr[index] = temp
  }
  return arr
}

/**
 * 插入排序: 将排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
 * 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
 * 最佳情况时间复杂度是O(nlogn),最差和平均情况是O(n^2) 空间复杂度为o(1)
 */

function binaryInsertSort(arr) {
  var len = arr.length
  for (var i = 1; i < len; i++) {
    var key = arr[i],
      left = 0,
      right = i - 1
    while (left <= right) {
      //在已排序的元素中二分查找第一个比它大的值
      var mid = (left + right) / 2 //二分查找的中间值
      if (key < arr[mid]) {
        //当前值比中间值小  则在左边的子数组中继续寻找
        right = mid - 1
      } else {
        left = mid + 1 //当前值比中间值大   在右边的子数组继续寻找
      }
    }
    for (var j = i - 1; j >= left; j--) {
      arr[j + 1] = arr[j]
    }
    arr[left] = key
  }
  return arr
}

/**
 * 一个单词奇数位抽出来做前半部分，偶数位倒序后做后半部分，拼接起来形成一个串，解密出原来的字符串
 */

var myReverse = (str) => {
  var res = ''
  for (let i = str.length - 1; i >= 0; i++) {
    res += str[i]
  }
  return res
}

var decode = (word) => {
  var len = word.length
  var mid = Math.floor(len - 1) / 2
  var left = word.slice(0, mid + 1)
  var right = myReverse(word.slice(mid + 1))
  let result = ''
  for (let j = 0; j < left.length - 1; j++) {
    result += left[j]
    if (j < right.length) {
      result += right[j]
    }
  }
}

/**
 * 获取二维数组里距离原点最近的k个点
 */
var sort = (arr, k) => {
  let a = arr.sort((a, b) => {
    return a[0] ** 2 + a[1] ** 2 - (b[0] ** 2 + b[1] ** 2)
  })
  return a.slice(0, k)
}